#include "thread_pool.hpp"
#include <iostream>

namespace timeout_manager {

ThreadPool::ThreadPool(size_t numThreads) : shutdown_(false) {
    std::cout << "创建线程池，线程数量: " << numThreads << " (ThreadPool::ThreadPool)"<< std::endl;
    
    // 预分配工作线程vector的空间
    workers_.reserve(numThreads);
    
    // 创建指定数量的工作线程
    for (size_t i = 0; i < numThreads; ++i) {
        workers_.emplace_back([this, i] { 
            std::cout << "工作线程 " << i << " 启动"<< " (ThreadPool::ThreadPool)" << std::endl;
            workerThread(); 
        });
    }
}

ThreadPool::~ThreadPool() {
    std::cout << "开始关闭线程池..." << " (ThreadPool::~ThreadPool)"<< std::endl;
    
    // 设置关闭标志
    shutdown_.store(true);
    
    // 通知所有等待的线程
    condition_.notify_all();
    
    // 等待所有线程完成
    for (auto& worker : workers_) {
        if (worker.joinable()) {
            worker.join();
        }
    }
    
    std::cout << "线程池已关闭" << " (ThreadPool::~ThreadPool)"<< std::endl;
}

void ThreadPool::submit(Task task) {
    // 如果正在关闭，不接受新任务
    if (shutdown_.load()) {
        std::cout << "线程池正在关闭，拒绝新任务" << " (ThreadPool::submit)"<< std::endl;
        return;
    }
    
    // 加锁保护任务队列
    {
        std::lock_guard<std::mutex> lock(queueMutex_);
        taskQueue_.push(std::move(task));
    }
    
    // 通知一个等待的线程有新任务
    condition_.notify_one();
}


size_t ThreadPool::getQueueSize() const {
    std::lock_guard<std::mutex> lock(queueMutex_);
    return taskQueue_.size();
}

void ThreadPool::workerThread() {
    // 工作线程的主循环
    while (!shutdown_.load()) {
        Task task;
        
        // 尝试获取任务
        {
            std::unique_lock<std::mutex> lock(queueMutex_);
            
            // 等待条件：关闭 或 有任务可执行
            condition_.wait(lock, [this] {
                return shutdown_.load() || !taskQueue_.empty();
            });
            
            // 如果正在关闭且没有任务，退出循环
            if (shutdown_.load() && taskQueue_.empty()) {
                break;
            }
            
            // 获取任务
            if (!taskQueue_.empty()) {
                task = std::move(taskQueue_.front());
                taskQueue_.pop();
            }
        }
        
        // 执行任务（在锁外执行，避免阻塞其他线程）
        if (task) {
            try {
                task();
            } catch (const std::exception& e) {
                std::cout << "任务执行异常: " << e.what() << " (ThreadPool::workerThread)"<< std::endl;
            } catch (...) {
                std::cout << "任务执行未知异常" << " (ThreadPool::workerThread)"<<std::endl;
            }
        }
    }
    
    std::cout << "工作线程退出" << " (ThreadPool::workerThread)"<<std::endl;
}

} // namespace timeout_manager